package logicaNegocio;

import java.util.*;

import logicaDatos.ConversorBD;


public class GestionAdministrador {
	private ArrayList<Campus> campus;
	private ArrayList<Aula> aulas;
	private Map<String,Grado> grados;
	private Iterator<?> it;
	private Campus c;	
	private nombreCampus nombreCampus;
	private nombreAsignatura nombreAsignatura;
	private nombreClaseAsignatura nombreClaseAsignatura;
	private nombrePerteneceAsignatura nombrePerteneceAsignatura;
	public GestionAdministrador (){
		
	}
	
	public void anadirAula (String Aforo, int Op)
	{	
		int aforo = Integer.parseInt(Aforo);
		Campus c = (Campus) getcampus().get(Op);
		boolean Comprobar = true;
		
		if (existe("Aula")== false)
		{
			for (int i = 0; i<getAulas().size();i++)
			{
				Aula A = (Aula) getAulas().get(i);
				if ((A.getAforoAula() == (aforo))&&(A.getCampus().getID()==(c.getID())))
				{
					Comprobar = false;
				}
			}
		}
		else
		{
			Comprobar = true;
		}
		
		if (Comprobar == true)
		{
			ConversorBD con=new ConversorBD();
			c = (Campus)con.leerCampus().get(Op);
			Aula A = new Aula(aforo, aforo,c);
			con.guardarAula(A);
		}
	}
	
	public void anadirCampus(String nombreCamp,String ciudadCamp,String telef)
	{
		boolean comprobar = true;
		int telefono = Integer.parseInt(telef); 
		if (existe("Campus")== false)
		{
		for (int i = 0; i<getcampus().size();i++)
		{
			Campus c = (Campus) getcampus().get(i);
			if ((c.getNombreCampus().equals(nombreCamp))&&(c.getTelefonoCampus()==telefono)&&(c.getCiudadCampus().equals(ciudadCamp)))
			{
				comprobar = false;
			}
		}
		}
		else
		{
			comprobar = true;
		}
		
		if (comprobar == true)
		{
			ConversorBD con=new ConversorBD();		
			Campus C = new Campus(nombreCamp, ciudadCamp, telefono,0,0);

			con.guardarCampus(C);
		}
	}

	public void anadirGrado (String nombreGrado,String caracteristicasGrado,String inforEconomica, int op)
	{
		ConversorBD con =new ConversorBD();
		c = con.leerCampus().get(op);
		float InforEcono = Float.parseFloat(inforEconomica); 
		Grado g = new Grado(nombreGrado, caracteristicasGrado, InforEcono);
		g.setCampus(c);
		con.guardarGrado(g);
	}
	
	public void anadirAsignatura (String nombreAsignatura,String credi,String caracteristicasAsignatura)
	{
		boolean Comprobar = true;
		int creditos = Integer.parseInt(credi); 
		
		if (existe("Asignatura")== false)
		{
			for (int i = 0; i<getAsignaturas().size();i++)
			{
				Asignatura A = (Asignatura) getAsignaturas().get(i);
				if ((A.getNombreAsignatura().equals(nombreAsignatura))&&(A.getNumeroCreditos()==creditos)&&(A.getCaracteristicasAsignatura().equals(caracteristicasAsignatura)))
				{
					Comprobar = false;
				}
			}
		}
		else
		{
			Comprobar = true;
		}
		
		if (Comprobar == true)
		{
			ConversorBD con=new ConversorBD();
			Asignatura A = new Asignatura(nombreAsignatura, creditos, caracteristicasAsignatura);
			con.guardarAsignatura(A);
		}
	}
	
	public void anadirProfesor (String Nombre, String Apellido, String Direccion,String Telefono, String Dni, String Sueldo,String Edad, Object Genero)
	{
		int telefono = Integer.parseInt(Telefono); 
		int edad = Integer.parseInt(Edad); 
		float sueldo = Float.parseFloat(Sueldo);
		String Ge = (String) Genero;
		ConversorBD con=new ConversorBD();	
		Profesor P = new Profesor(Nombre, Apellido, Direccion, telefono, Dni,  edad, sueldo, Ge);
		con.guardarProfesor(P);
	}
	
	public void anadirAlumno (String nombre, String apellido, String direccion,String telef, String dni,  String ed, int grado, String avatar, Object genero)
	{
		int telefono = Integer.parseInt(telef); 
		int edad = Integer.parseInt(ed);
		int K = 0;
		String ge = (String) genero;
		Alumno A = null;
		ConversorBD con=new ConversorBD();
		Grado g = null;
		it = con.leerGrado().entrySet().iterator();
		while (it.hasNext()) 
	    {
			@SuppressWarnings("rawtypes")
			Map.Entry e = (Map.Entry)it.next();
			g = (Grado) con.leerGrado().get(e.getKey());
	    	if (grado == K)
	    	{    		
	    		A = new Alumno(nombre, apellido, direccion, telefono, dni, edad,g, avatar,ge);

	    		con.guardarAlumno(A);
	    	}
	    	K++;
	    }
		campus = getcampus();

		getNoAlumnos(A.getGrado(),campus);
	}
	
	@SuppressWarnings("rawtypes")
	public void anadirClase(int profesor, int aula, int asignatura) 
	{
		boolean comprobar = true;
		int au = aula;
		int asig = asignatura;
		ConversorBD con=new ConversorBD();

		int K = 0;
		Aula a = con.leerAula().get(au);
		Asignatura as = con.leerAsignatura().get(asig);
		
		it = con.leerProfesor().entrySet().iterator();
		
		while (it.hasNext()) 
	    {
	    	
			Map.Entry e = (Map.Entry)it.next();
			Profesor p = con.leerProfesor().get(e.getKey());

	    	if (profesor == K)
	    	{
	    		if (existe("Clase")== false)
	    		{
					for (int i = 0; i<getClases().size();i++)
					{
						Clase c = (Clase) getClases().get(i);
						if ((c.getAsignatura().getNombreAsignatura().equals(as.getNombreAsignatura()))&&(c.getProfesor().getNombre().equals(p.getNombre())))
						{
							comprobar = false;
						}
					}
		    	}
	    		else
	    		{
	    			comprobar = true;
	    		}
	    		
				if (comprobar == true)
				{
		    		Clase c = new Clase(as,p,a);

		    		con.guardarClase(c);
				}
	    	}
	    	K++;
	    }			
	}
	
	public void anadirAsignaturaGrado(int asignatura, int grado) 
	{
		boolean comprobar = true;
		int asig = asignatura;
		ConversorBD con=new ConversorBD();
		int K = 0;
		Asignatura as = con.leerAsignatura().get(asig);
		
		it = con.leerGrado().entrySet().iterator();
		while (it.hasNext()) 
	    {
	    	
			@SuppressWarnings("rawtypes")
			Map.Entry e = (Map.Entry)it.next();
			Grado g =  con.leerGrado().get(e.getKey());
	    	if (grado == K)
	    	{
	    		if (existe("Pertenece")== false)
	    		{
		    		for (int i = 0; i<getAsignaturaGrado().size();i++)
					{
		    			Pertenece p = (Pertenece) getAsignaturaGrado().get(i);
						if ((p.getAsignatura().getNombreAsignatura().equals(as.getNombreAsignatura()))&&(p.getGrado().getNombreGrado().equals(g.getNombreGrado())))
						{
							comprobar = false;
						}
					}
	    		}
	    		else
	    		{
	    			comprobar = true;
	    		}
	    		
				if (comprobar == true)
				{
		    		Pertenece p = new Pertenece(as,g);
		    		con.guardarPerteneces(p);
				}
	    	}
	    	K++;
	    }
	}
	
	public void getNoAlumnos(Grado g, ArrayList<Campus> campus) 
	{
		ConversorBD con = new ConversorBD();
		for (int i = 0; i<campus.size();i++)
		{
			Campus c = campus.get(i);
			if (c.getNombreCampus().equals(g.getCampus().getNombreCampus()))
			{
				c.addNoCampus();
				con.actualizarCampus2(c, c.getID());
			}
		}
		
		
	}
	
	public void borrarAlumno(Alumno a)
	{
		ConversorBD con=new ConversorBD();
        con.borrarAlumno(a);
	}

	public void borrarProfesores(Profesor p) 
	{
		ArrayList<Clase>Clases = getClases();
		if(Clases.size() != 0)
		{
			Clase c;
			for(int i=0;i<Clases.size();i++)
			{
				c = (Clase) Clases.get(i);
				
				if(c.getProfesor().getDni().equals(p.getDni()))
				{
					borrarClase(c);
				}
			}
		}
		ConversorBD con=new ConversorBD();
		con.borrarProfesor(p);	
	}

	public void borrarClase(Clase c) 
	{
		ConversorBD con=new ConversorBD();
		con.borrarClase(c);
	}

	public void borrarAula(Aula a) 
	{
		ArrayList<Clase>Clases = getClases();
		if(Clases.size() != 0)
		{
			Clase c;
			for(int i=0;i<Clases.size();i++)
			{
				c = (Clase) Clases.get(i);System.out.print(c.getAsignatura());
				
				if(c.getAula().getID()==(a.getID()))
				{
					
					borrarClase(c);
				}
			}
		}
		ConversorBD con=new ConversorBD();
		con.borrarAula(a);
	}

	public void borrarGrado(Grado g) 
	{
		Map<String,Alumno>alumnos = getAlumnos();
		if(alumnos.size() != 0)
		{
			for (Map.Entry<String, Alumno> entry : alumnos.entrySet())
    		{
    			Alumno a = alumnos.get(entry.getKey());
				
				if(g.getID()==(a.getGrado().getID()))
				{
					borrarAlumno(a);
				}
			}
		}
		ArrayList<Pertenece>Perteneces = getAsignaturaGrado();
		if(Perteneces.size() != 0)
		{
			Pertenece p;
			for(int i=0;i<Perteneces.size();i++)
			{
				p = (Pertenece) Perteneces.get(i);
				
				if(p.getGrado().getID()==(g.getID()))
				{
					borrarPertenece(p);
				}
			}
		}
		ConversorBD con=new ConversorBD();		
		con.borrarGrado(g);
	}

	public void borrarPertenece(Pertenece p)
	{		
		ConversorBD con = new ConversorBD ();
		con.borrarPertenece(p);
	}

	public void borrarCampus(Campus c) 
	{
		Map<String,Grado>Grados= getGrados();
		if(Grados.size() != 0)
		{
			for (Map.Entry<String, Grado> entry : Grados.entrySet())
    		{
				Grado g = Grados.get(entry.getKey());
				
				if(c.getID()==(g.getCampus().getID()))
				{
					borrarGrado(g);
				}
			}
		}
		
		ArrayList<Aula>Aulas = getAulas();
		if(Aulas.size() != 0)
		{
			Aula a;
			for(int i=0;i<Aulas.size();i++)
			{
				a = (Aula) Aulas.get(i);
				
				if(a.getCampus().getID()==(c.getID()))
				{
					borrarAula(a);
				}
			}
		}
		ConversorBD con = new ConversorBD ();
		con.borrarCampus(c);
	}

	public void borrarAsignatura(Asignatura a) 
	{
		ArrayList<Clase>Clases = getClases();
		if(Clases.size() != 0)
		{
			Clase c;
			for(int i=0;i<Clases.size();i++)
			{
				c = (Clase) Clases.get(i);
				
				if(c.getAula().getID()==(a.getID()))
				{
					borrarClase(c);
				}
			}
		}
		ArrayList<Pertenece>Perteneces = getAsignaturaGrado();
		if(Perteneces.size() != 0)
		{
			Pertenece p;
			for(int i=0;i<Perteneces.size();i++)
			{
				p = (Pertenece) Perteneces.get(i);
				
				if(p.getAsignatura().getID()==(a.getID()))
				{
					borrarPertenece(p);
				}
			}
		}
		ConversorBD con = new ConversorBD ();
		con.borrarAsignatura(a);
	}

	public void actualizarProfesor(String nombre, String apellido, String direccion,String telef, String d, String s,String ed,int i, Object genero ) 
	{
		int K = 0;
		String Ge = (String) genero;
		Object claveProfesor=null;
		
		Map <String,Profesor> Profesores = getProfesores();
		it = Profesores.entrySet().iterator();
		while (it.hasNext()) 
	    {
			@SuppressWarnings("rawtypes")
			Map.Entry e = (Map.Entry)it.next();

	    	if (i == K)
	    	{
	    		claveProfesor = e.getKey();
	    	}
	    	K++;
	    }
				
		
		int telefono = Integer.parseInt(telef); 
		int edad = Integer.parseInt(ed); 
		float sueldo = Float.parseFloat(s); 
		
		String dni = (String) claveProfesor;
		ConversorBD con=new ConversorBD();
		Profesor p = new Profesor(nombre, apellido, direccion, telefono, dni,  edad, sueldo,Ge);
		con.actualizarProfesor(p,claveProfesor);

	}
	
	public void actualizarAlumno(String nombre, String apellido, String direccion,String telef, String d, String ed,int i, String avatares, Object genero) 
	
	{
		int K = 0;
		Object claveAlumno=null;
		
		Map <String,Alumno> Alumnos = getAlumnos();
		it = Alumnos.entrySet().iterator();
		
		while (it.hasNext()) 
	    {
			@SuppressWarnings("rawtypes")
			Map.Entry e = (Map.Entry)it.next();

	    	if (i == K)
	    	{
	    		claveAlumno = e.getKey();
	    	}
	    	K++;
	    }
		
		int telefono = Integer.parseInt(telef); 
		int edad = Integer.parseInt(ed);
		String ge = (String) genero;
		String dni = (String) claveAlumno;
		ConversorBD con=new ConversorBD();
		Alumno a = new Alumno(nombre, apellido, direccion, telefono, dni, edad,avatares, ge);
		con.actualizarAlumno(a,claveAlumno);
		
	}
	
	public void actualizarAsignatura(String nombreAsignatura,String creditos,String caracteristicasAsignatura,int i) 
	{
		getAsignaturas();
		
		ConversorBD con = new ConversorBD();
		
		int Creditos = Integer.parseInt(creditos);
		Asignatura a = new Asignatura (nombreAsignatura, Creditos, caracteristicasAsignatura);
		
		Asignatura as = getAsignaturas().get(i);
		
		con.actualizarAsignatura(a,as.getID());
		
		
	}
	
	public void actualizarAulas(String Aforo, int i) 
	{
		aulas = getAulas();
		
		ConversorBD con = new ConversorBD();
		Aula A = aulas.get(i);
		int aforo = Integer.parseInt(Aforo);
		Aula Au = new Aula (aforo);
		con.actualizarAula(Au, A.getID());
		
	}
	
	public void actualizarCampus(String nombreCamp,String ciudadCamp,String telefono, int i) 
	{
		campus = getcampus();
		
		ConversorBD con = new ConversorBD();

		Campus c = campus.get(i);
		int Telefono = Integer.parseInt(telefono);
		Campus ca = new Campus (nombreCamp, ciudadCamp,Telefono);
		con.actualizarCampus(ca, c.getID());
	}
	
	public void actualizarGrado(String nombreGrado,String caracteristicasGrado,String inforEcon, int i) 
	{
		grados = getGrados();
		int K = 0;
		Object clave = null;
		
		ConversorBD con = new ConversorBD();

		it = grados.entrySet().iterator();
		
		while (it.hasNext()) 
	    {
			@SuppressWarnings("rawtypes")
			Map.Entry e = (Map.Entry)it.next();

	    	if (i == K)
	    	{
	    		clave = e.getKey();
	    	}
	    	K++;
	    }
		
		Grado G = grados.get(clave);
		int inforEconomica = Integer.parseInt(inforEcon);
		Grado Gr = new Grado(nombreGrado,caracteristicasGrado,inforEconomica);
		G.actualizar(nombreGrado,caracteristicasGrado,inforEconomica);
		
		con.actualizarGrado(Gr, G.getID());
	}
	
	public ArrayList<Aula> getAulas () 
	{
		try
		{
		ConversorBD objCon=new ConversorBD();
		return objCon.leerAula();
		}
		catch (NullPointerException e)
		{
			return null;
		}
	}
	
	public ArrayList<Pertenece> getAsignaturaGrado ()
	{
		try
		{
		ConversorBD objCon=new ConversorBD();
		return objCon.leerPertenece();
		}
		catch (NullPointerException e)
		{
			return null;
		}		
	}
	
	public ArrayList<Clase> getClases () 
	{

		try{
		ConversorBD objCon=new ConversorBD();
		return objCon.leerClase();
		}
		catch (NullPointerException e)
		{
			return null;
		}	
	}
	
	public Map <String,Alumno>getAlumnos() 
	{
		
		try{
		ConversorBD objCon=new ConversorBD();
		return objCon.leerAlumno();
		}
		catch (NullPointerException e)
		{
			return null;
		}
	}
	
	public Map <String,Grado>getGrados ()
	{
		try{
		ConversorBD objCon=new ConversorBD();
		return objCon.leerGrado();
		}
		catch (NullPointerException e)
		{
			return null;
		}
	}
	
	public ArrayList<Campus> getcampus ()
	{
		try
		{
		ConversorBD objCon=new ConversorBD();
		return objCon.leerCampus();
		}
		catch (NullPointerException e)
		{
			return null;
		}
		
	}
	
	public ArrayList<Asignatura>getAsignaturas() 
	{
		try
		{
		ConversorBD objCon=new ConversorBD();
		return objCon.leerAsignatura();
		}
		catch (NullPointerException e)
		{
			return null;
		}
	}
	
	public Map <String,Profesor>getProfesores ()
	{
		try
		{
			ConversorBD objCon=new ConversorBD();
			return objCon.leerProfesor();

		}
		catch (NullPointerException e)
		{
			return null;
		}
		
		
	}

	public String getGrado(Object key) 
	{
		try
		{
		ConversorBD objCon=new ConversorBD();
		Grado G = objCon.leerGrado().get(key);
		return G.getNombreGrado();
		}
		catch (NullPointerException e)
		{
			return null;
		}

	}
	
	public String getCampus(int i) 
	{
		try
		{
		ConversorBD objCon=new ConversorBD();		
		Campus C = objCon.leerCampus().get(i);
		return C.getNombreCampus();
		}
		catch (NullPointerException e)
		{
			return null;
		}
	}
	
	public int getNombreAula(int i) 
	{
		try
		{
		ConversorBD objCon=new ConversorBD();		
		Aula A = objCon.leerAula().get(i);
		return A.getNumeroAula();
		}
		catch (NullPointerException e)
		{
			return 0;
		}
	}
	
	public String getNombreAsignatura(int i) 
	{
		try
		{
		ConversorBD objCon=new ConversorBD();	
		Asignatura A = objCon.leerAsignatura().get(i);
		return A.getNombreAsignatura();
		}
		catch (NullPointerException e)
		{
			return null;
		}
	}
	
	public String getNombreProfesor(Object key) 
	{
		try
		{
		ConversorBD objCon=new ConversorBD();	
		Profesor A = objCon.leerProfesor().get(key);
		return A.getNombre();
		}
		catch (NullPointerException e)
		{
			return null;
		}
	}	
	
	public Map <String, Alumno> ordenarAlumnos (Map<String,Alumno> alumnos)
	{
		Map <String,Alumno> A = new TreeMap<String, Alumno> ();
		A = alumnos;
		alumnos = A;
		return alumnos;
	}
	
	
	public Map <String, Profesor> ordenarProfesores (Map<String,Profesor> profesores)
	{
		Map <String,Profesor> P = new TreeMap<String, Profesor> ();
		P = profesores;
		profesores = P;
		return profesores;
	}
	
	public Map <String, Grado> ordenarGrados (Map<String,Grado> grados)
	{
		Map <String,Grado> G = new TreeMap<String, Grado> ();
		G = grados;
		grados = G;
		return grados;
	}
	
	public ArrayList<Campus> ordenarCampus(ArrayList<Campus> campus) 
	{
		Collections.sort(campus);
		return campus;
	}
	
	public ArrayList<Campus> ordenarCampusNombre(ArrayList<Campus> campus) 
	{
		Collections.sort(campus,nombreCampus);
		return campus;
	}

	class nombreCampus implements Comparator<Campus>
	{
		public int compare(Campus one, Campus two) 
		
			{
				return one.getNombreCampus().compareTo(two.getNombreCampus());
			}
	}
	
	public ArrayList<Asignatura> ordenarAsignaturas(ArrayList<Asignatura> asignaturas) 
	{
		Collections.sort(asignaturas);
		return asignaturas;
	}

	public ArrayList<Asignatura> ordenarAsignaturasNombre(ArrayList<Asignatura> asignaturas) 
	{
		Collections.sort(asignaturas,nombreAsignatura);
		return asignaturas;
	}
	
	class nombreAsignatura implements Comparator<Asignatura>
	{
		public int compare(Asignatura one, Asignatura two) 
		
			{
				return one.getNombreAsignatura().compareTo(two.getNombreAsignatura());
			}
	}
	
	public ArrayList<Aula> ordenarAulas(ArrayList<Aula> aulas) 
	{		
		Collections.sort(aulas);
		return aulas;
	}

	public ArrayList<Clase> ordenarClases(ArrayList<Clase> clases) 
	{
		Collections.sort(clases);
		return clases;
	}
	
	public ArrayList<Clase> ordenarClasesAsignatura(ArrayList<Clase> clases) 
	{
		Collections.sort(clases,nombreClaseAsignatura);
		return clases;
	}

	class nombreClaseAsignatura implements Comparator<Clase>
	{
		public int compare(Clase one, Clase two) 
		
			{
				return one.getAsignatura().getNombreAsignatura().compareTo(two.getAsignatura().getNombreAsignatura());
			}
	}
	
	public ArrayList<Pertenece> ordenarPerteneces(ArrayList<Pertenece> perteneces) 
	{
		Collections.sort(perteneces);
		return perteneces;
	}
	
	public ArrayList<Pertenece> ordenarPertenecesAsignatura(ArrayList<Pertenece> perteneces) 
	{
		Collections.sort(perteneces,nombrePerteneceAsignatura);
		return perteneces;
	}
	
	class nombrePerteneceAsignatura implements Comparator<Pertenece>
	{
		public int compare(Pertenece one, Pertenece two) 
		
			{
				return one.getAsignatura().getNombreAsignatura().compareTo(two.getAsignatura().getNombreAsignatura());
			}
	}
	public boolean existe (String eleccion)
	{
		ConversorBD c = new ConversorBD();
		return c.comprobarExiste(eleccion);
	}
}
